import Vue from "vue";
import App from "./App.vue";
import router from "./router";
import store from "./store";  


Vue.config.productionTip = false;

var vue = new Vue({
  router,
  store,
  render: h => h(App)
}).$mount("#app");

/*

*/
import axios from "axios";
import qs from 'Qs'
import Axios from "axios";
// axios.get('http://localhost:9090/MyBlog/vue/test.do?id=654321')
// axios.get('http://localhost:9090/MyBlog/vue/test.do',{
//   params: {
//     id: 654321
//     ,name: 'jack'
//   }
// })

axios.post('/api/b/httptrace',
{
  // 不设置conten type请求就会出问题
  headers: {'Content-Type': 'application/x-www-form-urlencoded'}
})
.then(function (response) {
  // alert(response);
  //var data = response.data;
  //alert(data[0].conpany);
  console.log("请求成功");
  console.log(response);
  console.log(response.data);
  console.log(response.data.name);
}).catch(function(error){
  console.log("请求失败");
  console.log(error);
  // alert(error);
});

axios.post('/api/integral/integraHistory/query',
{
  // 不设置conten type请求就会出问题
  headers: {'Content-Type': 'application/json'}
})
.then(function (response) {
  // alert(response);
  //var data = response.data;
  //alert(data[0].conpany);
  console.log("请求成功");
  console.log(response);
  console.log(response.data);
  console.log(response.data.name);
}).catch(function(error){
  console.log("#################################");
  console.log(error);
  // alert(error);
});

// qs.stringify 序列化解决后端接收参数的问题qs.stringify({size:20, page:1})
let objVO = {size: 30, page: 1};
axios.post('/api/integral/integraHistory/query', objVO,
{
  // 不设置conten type请求就会出问题
  headers: {'Content-Type': 'application/json'}
  // headers: {'Content-Type': 'application/x-www-form-urlencoded'}

})
.then(function (response) {
  // alert(response);
  //var data = response.data;
  //alert(data[0].conpany);
  console.log("请求成功");
  console.log(response);
  console.log(response.data);
  console.log(response.data.name);
}).catch(function(error){
  console.log("#################################");
  console.log(error);
  // alert(error);
});

// Axios.interceptors.response.use(response => {
//   return response
// }, error => {
//   if(error && error.response) {
//     switch (error.response/status) {
//       case 400:
//         error.message = '错误请求'
//         break;
//       case 401:
//         error.message = '未授权，请重新登录'
//         break;
//       case 403:
//         error.message = '拒绝访问'
//         break;
//       case 404:
//         error.message = '请求错误，未找到该资源'
//         break;
//       case 405:
//         error.message = '请求方法未允许'
//         break;
//       case 408:
//         error.message = '请求超时'
//         break;
//       case 500:
//         error.message = '服务端出错'
//         break;
//       case 501:
//         error.message = '网络未实现'
//         break;
//       case 502:
//         error.message = '网络错误'
//         break;
//       case 503:
//         error.message = '服务不可用'
//         break;
//       case 504:
//         error.message = '网络超时'
//         break;
//       case 505:
//         error.message = 'http版本不支持该请求'
//         break;
//       default:
//         error.message = `链接错误${error.response.status}`
//     }
//   }else {
//     error.message = "网络出现问题，请稍后再试";
//   }
// })

// function getUserAccount() {
//   return axios.get('/user/12345');
// }

// function getUserPermissions() {
//   return axios.get('/user/12345/permissions');
// }

// axios.all([getUserAccount(), getUserPermissions()])
//   .then(axios.spread(function (acct, perms) {
//     // 两个请求现在都执行完成
//   }));

/* Set结构 */

let setobj = new Set();
setobj.add(1);
setobj.add(3);
//delete(val)        删元素
//clear()            删除所有数据
console.log(setobj.size);
console.log(setobj.has(1));

// 遍历
// for of 遍历数据
for(let i of setobj) {
  console.log(i);
}
// 遍历 keys    等于遍历set
for (let i of setobj.keys()){
  console.log(i);
}
// 遍历values
for (let i of setobj.values()){
  console.log(i);
}
// 遍历对象实体 entries
for (let i of setobj.entries()){
  console.log(i[0]);
}

// 解构的方式遍历对象实体
console.log('解构的方式遍历对象实体');
let [k, v] = setobj;
console.log(k, v);

for(let [k,v] of setobj.entries()){
  console.log(k, v);
}

// for each 遍历 set
console.log('for each 遍历 set');
setobj.forEach(element => {
  console.log(element);
});


/* 对象扩展 */
    let name = "necy";
    let age = 22;
  

    let util = {
        name,
        age,
        walk: function () {
            console.log(this.name + " is walk");
        },
        say() {
            console.log(this.name + ` say`);
        },
        topLabel: function (val) {
          console.log('##################### '+val+' #####################');
        },
        secLabel: function (val) {
          console.log('================== '+val+' ==================');
        },
        print: function(val){
          console.log(val);
        }
    };
    util.walk();
    util.walk();
    console.log('============='+util.name);

console.log("#####################模板字符串 反引号 ``####################");
let obj = {
  name:'jack',
  age: 20
}
console.log(`${obj.name}`);

console.log("#####################字符串的遍历####################");
console.log("==================or遍历==================");
let str = "hello";
//1.for遍历
for (let i = 0; i < str.length; i++) {
    console.log(i, str[i]);     //i 索引    数值类型
}

console.log("==================数组->for->for in==================");
//2.数组->for->for in
let arr = [1, 2, 3];
for (let i in arr) {
    console.log(i, arr[i]);     //i 索引    字符串类型
}

console.log("==================for... of==================");
//3.for... of
for(let i of str){
    console.log(i);     //数据
}

console.log("==================解构==================");
//4.解构
let [a, b, c, d ,e] = str;
console.log(a, b, c, d ,e);


/* Map结构 */
util.topLabel('Map结构');
let map1 = new Map();
util.secLabel('添加');
map1.set('name', 'liming');
// 多个添加
map1.set('name', 'jack').set('age', 22).set(0,100);
console.log(map1.get('name'));
console.log(map1.get(0));
//has(key)            判断是否包含元素     boolean
//clear()             删除所有数据
util.print(map1);

// map 支持数组作为构造函数的参数,但必须是二维数组
let arrMap = [['name', 'jack'], ['age', 12]];
let map2 = new Map(arrMap);
util.print(map2);

// Map的遍历
util.topLabel('Map的遍历');
for(let i of map2){
  util.print([i[0], i[1]]);
}
util.secLabel(' ');
map2.forEach((v, k) => {
  util.print([k, v]);
})
util.secLabel(' ');
for(let k of map2.keys()){
  util.print([k, map2.get(k)]);
}
util.secLabel(' ');
for(let v of map2.values()){
  util.print(v);
}
util.secLabel('');
for (let i of map2.entries()){
  util.print([i[0], i[1]])
}
util.secLabel('');
for(let [k, v] of map2.entries()){
  util.print([k, v]);
}

let arr1 = [1,2,3,4,5];
// ... 扩展运算符其中之一的作用如下
util.print(...arr1);  // [1, 2, 3, 4, 5]
util.print(arr1); // [Array(3)]

util.topLabel('继承');
class Person {
  constructor(uname, uage) {
    this.uname = uname;
    this.uage = uage;

  }
  // 成员方法
  walk() {
    util.print(`${this.uname}正在奔跑！`);
  }

  // 静态方法： 类自身的方法
  static cry(){
    util.print('人生下来就会哭！');
  }
}
// 静态属性
Person.living = 'earth';

// 学生类继承Person类
class Student extends Person{
  constructor(sname, sage, sno){
    super(sname, sage);
    this.sno = sno;
  }

  // 成员方法
  study(){
    util.print(`${this.sname}在学习呢！`);
  }
  // set 访问器 控制属性的设置
  set sage (age){
    this.sage = age;
  }

  /* get sage(){
    return this.sage;
  } */
}
let stu = new Student('jack', 23, '001');
stu.walk();
util.print(stu.living);
